home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / M2Crypto / BIO.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  8.8 KB  |  271 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import m2
  5. from m2 import bio_do_handshake as bio_do_ssl_handshake
  6. from cStringIO import StringIO
  7.  
  8. class BIOError(Exception):
  9.     pass
  10.  
  11. m2.bio_init(BIOError)
  12.  
  13. class BIO:
  14.     m2_bio_free = m2.bio_free
  15.     
  16.     def __init__(self, bio = None, _pyfree = 0, _close_cb = None):
  17.         self.bio = bio
  18.         self._pyfree = _pyfree
  19.         self._close_cb = _close_cb
  20.         self.closed = 0
  21.         self.write_closed = 0
  22.  
  23.     
  24.     def __del__(self):
  25.         if self._pyfree:
  26.             self.m2_bio_free(self.bio)
  27.         
  28.  
  29.     
  30.     def _ptr(self):
  31.         return self.bio
  32.  
  33.     bio_ptr = _ptr
  34.     
  35.     def fileno(self):
  36.         return m2.bio_get_fd(self.bio)
  37.  
  38.     
  39.     def readable(self):
  40.         return not (self.closed)
  41.  
  42.     
  43.     def read(self, size = None):
  44.         if not self.readable():
  45.             raise IOError, 'cannot read'
  46.         
  47.         if size is None:
  48.             buf = StringIO()
  49.             while None:
  50.                 data = m2.bio_read(self.bio, 4096)
  51.                 if not data:
  52.                     break
  53.                 
  54.                 continue
  55.                 return buf.getvalue()
  56.         size is None
  57.         if size == 0:
  58.             return ''
  59.         elif size < 0:
  60.             raise ValueError, 'read count is negative'
  61.         else:
  62.             return m2.bio_read(self.bio, size)
  63.  
  64.     
  65.     def readline(self, size = 4096):
  66.         if not self.readable():
  67.             raise IOError, 'cannot read'
  68.         
  69.         buf = m2.bio_gets(self.bio, size)
  70.         return buf
  71.  
  72.     
  73.     def readlines(self, sizehint = 'ignored'):
  74.         if not self.readable():
  75.             raise IOError, 'cannot read'
  76.         
  77.         lines = []
  78.         while None:
  79.             buf = m2.bio_gets(self.bio, 4096)
  80.             if buf is None:
  81.                 break
  82.             
  83.             continue
  84.             return lines
  85.  
  86.     
  87.     def writeable(self):
  88.         if not (self.closed):
  89.             pass
  90.         return not (self.write_closed)
  91.  
  92.     
  93.     def write(self, data):
  94.         if not self.writeable():
  95.             raise IOError, 'cannot write'
  96.         
  97.         return m2.bio_write(self.bio, data)
  98.  
  99.     
  100.     def write_close(self):
  101.         self.write_closed = 1
  102.  
  103.     
  104.     def flush(self):
  105.         m2.bio_flush(self.bio)
  106.  
  107.     
  108.     def reset(self):
  109.         return m2.bio_reset(self.bio)
  110.  
  111.     
  112.     def close(self):
  113.         self.closed = 1
  114.         if self._close_cb:
  115.             self._close_cb()
  116.         
  117.  
  118.     
  119.     def should_retry(self):
  120.         return m2.bio_should_retry(self.bio)
  121.  
  122.     
  123.     def should_read(self):
  124.         return m2.bio_should_read(self.bio)
  125.  
  126.     
  127.     def should_write(self):
  128.         return m2.bio_should_write(self.bio)
  129.  
  130.  
  131.  
  132. class MemoryBuffer(BIO):
  133.     
  134.     def __init__(self, data = None):
  135.         BIO.__init__(self)
  136.         self.bio = m2.bio_new(m2.bio_s_mem())
  137.         self._pyfree = 1
  138.         if data is not None:
  139.             m2.bio_write(self.bio, data)
  140.         
  141.  
  142.     
  143.     def __len__(self):
  144.         return m2.bio_ctrl_pending(self.bio)
  145.  
  146.     
  147.     def read(self, size = 0):
  148.         if not self.readable():
  149.             raise IOError, 'cannot read'
  150.         
  151.         if size:
  152.             return m2.bio_read(self.bio, size)
  153.         else:
  154.             return m2.bio_read(self.bio, m2.bio_ctrl_pending(self.bio))
  155.  
  156.     getvalue = read_all = read
  157.     
  158.     def write_close(self):
  159.         self.write_closed = 1
  160.         m2.bio_set_mem_eof_return(self.bio, 0)
  161.  
  162.     close = write_close
  163.  
  164.  
  165. class File(BIO):
  166.     
  167.     def __init__(self, pyfile, close_pyfile = 1):
  168.         BIO.__init__(self, _pyfree = 1)
  169.         self.pyfile = pyfile
  170.         self.close_pyfile = close_pyfile
  171.         self.bio = m2.bio_new_fp(pyfile, 0)
  172.  
  173.     
  174.     def close(self):
  175.         self.closed = 1
  176.         if self.close_pyfile:
  177.             self.pyfile.close()
  178.         
  179.  
  180.  
  181.  
  182. def openfile(filename, mode = 'rb'):
  183.     return File(open(filename, mode))
  184.  
  185.  
  186. class IOBuffer(BIO):
  187.     m2_bio_pop = m2.bio_pop
  188.     m2_bio_free = m2.bio_free
  189.     
  190.     def __init__(self, under_bio, mode = 'rwb', _pyfree = 1):
  191.         BIO.__init__(self, _pyfree = _pyfree)
  192.         self.io = m2.bio_new(m2.bio_f_buffer())
  193.         self.bio = m2.bio_push(self.io, under_bio._ptr())
  194.         self._under_bio = under_bio
  195.         if 'w' in mode:
  196.             self.write_closed = 0
  197.         else:
  198.             self.write_closed = 1
  199.  
  200.     
  201.     def __del__(self):
  202.         if getattr(self, '_pyfree', 0):
  203.             self.m2_bio_pop(self.bio)
  204.         
  205.         self.m2_bio_free(self.io)
  206.  
  207.     
  208.     def close(self):
  209.         BIO.close(self)
  210.  
  211.  
  212.  
  213. class CipherStream(BIO):
  214.     SALT_LEN = m2.PKCS5_SALT_LEN
  215.     m2_bio_pop = m2.bio_pop
  216.     m2_bio_free = m2.bio_free
  217.     
  218.     def __init__(self, obio):
  219.         BIO.__init__(self, _pyfree = 1)
  220.         self.obio = obio
  221.         self.bio = m2.bio_new(m2.bio_f_cipher())
  222.         self.closed = 0
  223.  
  224.     
  225.     def __del__(self):
  226.         if not getattr(self, 'closed', 1):
  227.             self.close()
  228.         
  229.  
  230.     
  231.     def close(self):
  232.         self.m2_bio_pop(self.bio)
  233.         self.m2_bio_free(self.bio)
  234.         self.closed = 1
  235.  
  236.     
  237.     def write_close(self):
  238.         self.obio.write_close()
  239.  
  240.     
  241.     def set_cipher(self, algo, key, iv, op):
  242.         cipher = getattr(m2, algo, None)
  243.         if cipher is None:
  244.             raise ValueError, ('unknown cipher', algo)
  245.         
  246.         m2.bio_set_cipher(self.bio, cipher(), key, iv, op)
  247.         m2.bio_push(self.bio, self.obio._ptr())
  248.  
  249.  
  250.  
  251. class SSLBio(BIO):
  252.     
  253.     def __init__(self, _pyfree = 1):
  254.         BIO.__init__(self, _pyfree)
  255.         self.bio = m2.bio_new(m2.bio_f_ssl())
  256.         self.closed = 0
  257.  
  258.     
  259.     def set_ssl(self, conn, close_flag = m2.bio_noclose):
  260.         self._pyfree = 0
  261.         m2.bio_set_ssl(self.bio, conn.ssl, close_flag)
  262.         if close_flag == m2.bio_noclose:
  263.             conn.set_ssl_close_flag(m2.bio_close)
  264.         
  265.  
  266.     
  267.     def do_handshake(self):
  268.         return m2.bio_do_handshake(self.bio)
  269.  
  270.  
  271.